Protecting application programs from malicious software or malware

ABSTRACT

A computer system, includes a crypto mechanism that decrypts and integrity-checks Secure Object information as the Secure Object information moves into the computer system from an external storage and encrypts and updates an integrity value for Secure Object information as the Secure Object information moves out of the computer system to the external storage.

RELATED APPLICATIONS

This Application is a Continuation Application of U.S. patent application Ser. No. 13/226,079, filed on Sep. 6, 2011.

CROSS-REFERENCE TO RELATED APPLICATIONS

The present application is related to the following co-pending applications:

U.S. patent application Ser. No. 12/492,738, filed on Jun. 26, 2009, to Richard H. Boivie, entitled “SUPPORT FOR SECURE OBJECTS IN A COMPUTER SYSTEM”;

U.S. patent application Ser. No. 12/878,696, filed on Sep. 9, 2010, to Richard H. Boivie, entitled “CACHE STRUCTURE FOR A COMPUTER SYSTEM PROVIDING SUPPORT FOR SECURE OBJECTS”;

U.S. patent application Ser. No. 13/033,455, filed on Feb. 23, 2011, to Boivie, et al., entitled “BUILDING AND DISTRIBUTING SECURE OBJECT SOFTWARE”; and

U.S. patent application Ser. No. 13/033,367, filed on Feb. 23, 2011, to Boivie, et al., entitled “SECURE OBJECT HAVING PROTECTED REGION, INTEGRITY TREE, AND UNPROTECTED REGION,

all assigned to the present assignee, and incorporated herein by reference.

BACKGROUND OF THE INVENTION Field of the Invention

The present invention generally relates to protecting an application executing on a computer not only from attacks from “outside” the application but also from attempts to introduce malware “inside” the application through vulnerabilities in the application's interfaces. More specifically, the esm (EnterSecurityMode) instruction previously described in the above-identified co-pending applications, is extended to include two additional address range fields, a first of which tells the CPU hardware that the address range corresponding to code is “read only” from the perspective of the application, and the second of which tells the hardware that the address range corresponding to the application's data, stack, and heap is “no-execute.”

Description of the Related Art

IBM Research has been developing an innovative secure processor architecture that provides for verifiably secure applications. The architecture protects the confidentiality and integrity of information in an application so that ‘other software’ cannot access that information or undetectably tamper with it.

The present invention protects an application not only from attacks from “outside” the application but also from attempts to introduce malware “inside” the application through vulnerabilities in the application's interfaces.

SUMMARY OF THE INVENTION

In view of the foregoing, and other, exemplary problems, drawbacks, and disadvantages of the previously-described security systems, it is an exemplary feature of the present invention to provide a structure (and method) in which an application is protected not only from attacks from “outside” the application but also from attempts to introduce malware “inside” the application.

It is another exemplary feature of the present invention to provide a structure and method for providing a mechanism using address ranges to provide protection against attempts to introduce malware “inside” the application.

In a first exemplary aspect, described herein is an apparatus including a memory to store a secure object comprising at least one of code and data that is encrypted when stored in said memory; and a central processing unit (CPU) capable of executing an EnterSecureMode (esm) instruction that enables decryption of the secure object information when the secure object information is retrieved from said memory into said CPU, the CPU further including a feature to protect the secure object from attacks that attempt to insert executable code into the secure object.

In a second exemplary aspect, also described herein is a method of enhancing security on a computer, including: providing an access to a memory to store a secure object comprising at least one of code and data that is encrypted when stored in the memory; and providing an EnterSecureMode (esm) instruction that enables decryption of the secure object information when the secure object information is retrieved from the memory into a central processing unit (CPU) of the computer, the CPU further including a feature to protect the secure object from code that the secure object receives from other software.

In a third exemplary aspect, also described herein is a controller for a computer, the controller including a memory device tangibly embodying a set of machine-readable instructions: providing an access to a memory to store a secure object comprising at least one of code and data that is encrypted when stored in the memory; and providing control of an EnterSecureMode (esm) instruction that enables decryption of the secure object's information when the secure object information is retrieved from the memory into a central processing unit (CPU) of the computer, the CPU further including a feature to protect the secure object from code that the secure object receives from other software.

Thus, in addition to protecting a secure application from attacks from “outside” the application, the architecture described by the present invention also protects against attempts to introduce malware “inside” the application, via attacks such as buffer overflow or stack overflow attacks. This architecture provides a foundation for providing strong end-to-end security in a network environment.

This new architecture, which the present inventors refer to as “SecureBlue++”, builds upon the earlier “SecureBlue” secure processor technology, which has been used in tens of millions (i.e., 55 million, as of the time of filing this application) of CPU chips to protect sensitive information from physical attacks.

BRIEF DESCRIPTION OF THE DRAWINGS

The foregoing and other purposes, aspects and advantages will be better understood from the following detailed description of an exemplary embodiment of the invention with reference to the drawings, in which:

FIG. 1 shows the basic capability of the SecureBlue++ architecture 100, as introduced in the co-pending applications;

FIG. 2 exemplarily shows the mechanism 200 of the EnterSecureMode (esm) instruction, as used in the basic SecureBlue++ architecture;

FIG. 3 exemplarily demonstrates in schematic format 300 the content and different regions of a secure object-based executable file;

FIG. 4 exemplarily shows in schematic format 400 how a SecureBlue++ system can provide strong protection for an application's information including protection of that information while it is in memory, on disk, on network links or while it is in an operating system on its way to a network;

FIG. 5 exemplarily shows the esm instruction word format 500 for SecureBlue++ including the two new address ranges used by the current invention; and

FIG. 6 shows an example of a computer architecture 600, including the CPU registers 601, 602 that implement the “read only” and “no-execute” ranges specified in the esm instruction.

EXEMPLARY EMBODIMENTS OF THE INVENTION

Referring now to the drawings, exemplary embodiments of the method and structures according to the present invention are now discussed.

The above-identified co-pending applications described the SecureBlue++ mechanisms that protect the confidentiality and integrity of information in an application program from an “external attack” so that “other software” outside of the application cannot read or undetectably tamper with information inside the application. As discussed in these co-pending applications, “other software” means all the other software on a system including other applications as well as privileged software, like the operating system, device drivers, or applications running with root (or superuser) privileges, or malware that obtains root privileges by exploiting a vulnerability in privileged software. In a SecureBlue++ system, information is “in the clear” when it is inside the CPU chip but encrypted whenever it is outside the CPU chip boundary. This encryption protects the confidentiality and integrity of code and data from physical probing or physical tampering.

SecureBlue++ builds upon SecureBlue, and is exemplarily shown in the configuration 100 of FIG. 1. Like the previous SecureBlue technology, SecureBlue++ protects against physical attacks (e.g., label 101 shows how code and data is encrypted when in memory but gets decrypted to become visible when executed in the CPU), but SecureBlue++ additionally uses “fine-grained” SecureBlue-like crypto protection with context-labeling in the CPU that also protects the confidentiality and integrity of information in an application from all the other software on a system. Thus, SecureBlue++ adds features, described by label 102, to the SecureBlue mechanism so that code and data in one application is protected from other software, including the operating system, device drivers and other programs.

Importantly, it does this in a way that is largely transparent to applications.

As exemplarily shown in FIG. 2, in the previously-described SecureBlue++ mechanism, when an application's information is outside the processor chip 201 (e.g., when the application is in the file system prior to execution, or when it is in memory 202 or in the paging system during execution) it is encrypted under keys 203,204 that are not available to any other software and an integrity tree is used to detect tampering. Integrity protection (as well as confidentiality protection) is continuous—not just at application launch time. When an application's information is inside the CPU chip 201 (e.g., in on-chip caches), it is in the clear and context labels prevent other software from accessing or tampering with that information.

Since an application's information is encrypted whenever it is outside the CPU and since other software cannot access an application's cleartext information inside the CPU, other software such as the page demon or malware can only see the encrypted form of an application's information. Thus an application's information is protected from all the other software on the system including privileged software like the operating system, device drivers or applications running with root privileges—or malware that obtains root privileges by exploiting a vulnerability in privileged software.

Unlike systems that “measure” boot code, operating system code and device driver code at system boot time and then trust this code during execution, in our architecture, an application does not need to trust the operating system or any other software. An application in a SecureBlue++ system uses operating system services for scheduling, paging, I/O, interrupt handling etc. but it does not trust the operating system with any sensitive information. This is analogous to the way 401 we use the Internet today when we make an online purchase via https. We use the Internet to transport our packets but we do not give it access to any sensitive information in these packets. A malicious network operator may delay or drop the packets, but it cannot violate their confidentiality or integrity. In similar fashion, the SecureBlue++ technology allows an application to use operating system services e.g. scheduling, I/O, paging, interrupt handling without giving the operating system or device drivers access to any sensitive information.

A SecureBlue++ system thus minimizes the amount of code that needs to be trusted. The only code that an application needs to trust is the code within the application. SecureBlue++ allows us to know with a high level of confidence that information in an application is secure without having to prove the correctness of millions of lines of operating system, device driver, boot and other code. We only need to prove the correctness of the application.

As discussed above, the information in an application is cryptographically protected when the application is in a file system as well as throughout execution. This information is also protected while the application is in-transit prior to installation in the file system. Since the information in an application is always protected, the user can “compile in” a root (or roots) of trust that cannot be stolen or tampered with. Since a “compiled in” private key cannot be stolen, strong protection is provided against key theft and identity spoofing. And since a “compiled in” digital certificate cannot be tampered with, strong protection is provided for a chain of trust that allows an application to determine the authenticity of other entities in a network. Importantly, these roots of trust are protected from 1) an adversary that has root access to the system or 2) a malware-infected operating system.

Secure Applications (Also Known as Secure Executables)

In the architecture of the present invention, a secure application consists of 1) a cryptographically protected region containing encrypted code and data, 2) an initial integrity tree that protects the integrity of the protected region, and 3) an unprotected region that includes “communication” buffers and a loader that includes a new CPU instruction. As shown in FIG. 2, the esm instruction causes the CPU to ‘enter secure mode’ and process the encrypted code and data. Encrypted code and data is decrypted and checked for integrity in hardware as it is brought into the CPU chip (i.e. into an on-chip cache) from external memory; and data is encrypted and integrity tree values are updated as information (i.e. dirty cache lines) are written out to external memory. The operand of the esm instruction, which includes the key for accessing the encrypted code and data as well as the initial value for the root of the integrity tree, is itself protected by a ‘system key’ that is not available to any software. Inset 210 of FIG. 2 exemplarily shows a portion of a secure object as residing in external memory 202.

Thus other software, such as ‘memory scraping’ malware cannot access or undetectably tamper with information in a secure application. (The esm operand is protected by a public/private key pair. The build machine encrypts the esm operand with the public key of the target machine. The private key, which is installed in the target machine at manufacture time, is used by the esm instruction at run-time to decrypt the operand.) In addition to loading the application's encryption key and integrity root into the crypto hardware, the esm instruction also allocates an ID, the Executable-ID or EID, that the hardware and the operating system will use to refer to this ‘secure executable’.

As discussed above, information is stored in the clear in on-chip caches so cryptographic operations only occur when information moves between on-chip caches and external memory. In similar fashion, the checking and updating of integrity values only occur when information moves between on-chip caches and external memory. Thus the cryptographic and integrity overhead is close to zero when a secure application is getting cache hits.

FIG. 3 exemplarily shows a format 300 of a secure object executable file. The file contains (1) the Secure Object code and data in encrypted form 301, (2) the initial version of an integrity tree 302 that will be used at run-time to protect the integrity of the Secure Object's code and data, and (3) loader code including an esm instruction (in 303) to ‘Enter Secure Mode’. As discussed in the first co-pending patent application above, the esm instruction allows a Secure Object's sensitive information to be decrypted on the path from external memory into the CPU and encrypted on the path from CPU to external memory.

FIG. 3 also shows communication buffers in the unprotected region 303. Thus, the unshaded region 303 of the binary file is an unprotected region that includes a loader, the esm instruction including the esm operand (or handle), and communication buffers. The shaded regions include the integrity tree 302 and the encrypted region 301 that includes one or more of code, data, stack, and heap data. The code and data are encrypted so that only the target CPU can read the binary, and only in secure mode.

Using the Operating System without Trusting the Operating System

As discussed above, a secure application (or secure executable) uses operating system services but does not trust the operating system with any sensitive information. In the paging subsystem for example, the operating system moves an application's pages between memory and disk but the pages are encrypted and the operating system has no access to the encryption key(s).

Another example is in network I/O. An application uses buffers in the unprotected region to send packets to and receive packets from a remote system. Since these buffers are in the unprotected region, they are not protected by the SecureBlue++ crypto. Thus the operating system and the remote system “see” the same information that the secure application “sees”. On the other hand, if the contents of a buffer were cryptographically protected by the SecureBlue++ crypto protection, the operating system and the remote system would not be able to “see” the content that the secure application “sees”.

Since the CPU decrypts information that moves from a protected region in external memory into the CPU and since the CPU does not encrypt information that moves from the CPU to an unprotected region in external memory, the act of copying information from the protected region to the unprotected region has the effect of decrypting the information. Information in this region can be sent to a remote system and the remote system will be able to read it. Similarly the act of copying information from the unprotected region to the protected region has the effect of encrypting it under the secure application's encryption key. This is useful when information is received from a remote entity.

Note that although the unprotected region is not protected by the SecureBlue++ encryption, information in that region can still be cryptographically protected. Standard communications security mechanisms such as SSL or TLS can be used to provide end-to-end security. If a message that is to be sent to a remote system is encrypted under TLS before it is moved into the unprotected region, the message will be protected in the unprotected region in the same way that it is protected while it is traveling across a network. If, at the receiving end, the message is moved to the protected region before the TLS decryption, the message will have strong protection end-to-end with no point of vulnerability along the way, as shown in FIG. 4.

Note that the keys that a secure application uses for TLS or other communications security will be protected so other software including the operating system will not be able to access those keys or the packets protected by those keys, or undetectably tamper with either the keys or the packets. Keys inside a secure application can also be used to protect information stored in a file system, and other software including the operating system will not be able to access those keys or the contents of the files protected by those keys, as shown in FIG. 4.

System call “wrappers” can be linked with a secure application so that the application does not need to know about the protected and unprotected regions. These “wrappers” are library function that invoke the actual system calls and copy the contents of buffers between the protected and unprotected regions in a way that is transparent to the application while allowing the application to communicate intelligibly with remote systems.

In addition to hiding some complexity from the programmer, the wrappers also allow us to convert an existing application into a secure application in a way that is largely transparent to the application program.

Secure Context Switching

As discussed above, the operating system, device drivers and other software do not have access to a secure executable's information. When a secure executable is interrupted, the CPU hardware securely saves certain information before the OS or device drivers get control including the contents of the general purpose registers and the secure executable's encryption key and integrity root. When the operating system gets control, it has no access to any of this information (or the contents of the secure executable's cryptographically protected ‘protected region’) but it does have access to the EID of the secure executable that was interrupted—which is available in a (new) register. The operating system uses a new instruction, restorecontext, to securely restore and dispatch a previously suspended secure executable. The operand of this instruction is the EID of the secure executable to be dispatched. A third new instruction, deletecontext, is used by the operating system at process exit to indicate to the CPU that a secure process has completed execution and that the CPU can de-allocate its EID and free any resources associated with that EID

Software Build Process

The make process for a secure executable/secure application doesn't require any changes to programming languages, compilers or link-editors. An application is compiled in the usual manner and then linked with the wrappers discussed above and with a loader that includes the esm instruction (with a placeholder for the esm operand). An integrity tree is built for the code and data that will comprise the protected region and the protected region is then encrypted with a randomly generated symmetric key. The symmetric key and the root of the integrity tree are then encrypted under the public key of the target system to form the operand of the esm instruction. Finally, the integrity tree is combined with the protected region and the loader to form the complete secure executable binary.

Protecting from “Attacks from the Inside” Such as Stack and Buffer Overflow

As discussed above, SecureBlue++ can protect the confidentiality and integrity of information in an application from “external attack” so that “other software” cannot access or undetectably tamper with information inside the application. It can also protect an application from an “internal attack” in which an attacker attempts to exploit a vulnerability in an application's interfaces to get the application to execute code of the attacker's choosing via a software attack such as a buffer overflow or stack overflow attack.

As discussed above, the esm instruction enables the use of cryptographic hardware that protects the confidentiality and integrity of information in an application from “external attack”. The esm instruction also establishes the address range that will be protected by the cryptographic hardware. As discussed previously, some portions of the address space (e.g. communication buffers) are not cryptographically protected.

To protect against attacks such as stack overflow and buffer overflow, the esm instruction will also set up two additional address ranges for an application. One of these will tell the CPU hardware that the address range corresponding to the application's code is, from the application's perspective, “read-only”. The other will tell the hardware that the address range corresponding to the application's data, stack and heap is “no-execute”. Thus if an attacker attempts to exploit a bug in an application so that the application will attempt to write into the code region or execute instructions from the data region, the attempt will fail.

As in the case of the encryption key and integrity root registers, the address range registers will be set by the CPU hardware in the execution of the esm instruction. These registers will not be accessible to software and they will be saved and restored by the CPU hardware during a context switch along with the encryption key and integrity root registers.

FIG. 5 exemplarily shows a format 500 of the esm operand as including the two new fields 501, 502 for protecting against attempts to introduce malware inside an application. The esm operand also includes the encryption key 504 that is used to decrypt and encrypt Secure Object code and data, as that information moves between the CPU and external memory, and the initial value 505 of the root of the hash tree that protects the integrity of the Secure Object code and data.

Thus, the present invention describing SecureBlue++ extends the functionality of the esm instruction described in the co-pending applications by setting up two additional ranges for an application, the above-described address range which tells the CPU hardware that the application's code is “read-only”, and the above-described address range, which tells the CPU hardware that the application's data, stack, and heap is “no-execute”.

In an alternate design, a single additional address range could be used to specify both the “read-only” and “no-execute” regions within the larger cryptographically protected region. For example, the additional address range could be used to specify that a portion of the cryptographically protected region is “read-only” and the rest is “no-execute”.

So, if an attacker attempts to exploit a vulnerability in an application interface so that the application will attempt to write into the code region or execute instructions from the data region in order to get the application to execute code of the attacker's choosing, the attempt will fail.

As in the case of the encryption key and integrity root registers, these address ranges will be set by the CPU hardware in the execution of an esm instruction. These registers will not be accessible by software and will be saved and restored by the hardware during a context switch along with the encryption key and integrity root registers.

FIG. 6 shows an exemplary computer configuration 600 that could be used to implement the present invention, including the “NO-EXECUTE” and “READ ONLY” registers 601,602 along with the CPU controller 603 that would enforce the “READ ONLY” and “NO-EXECUTE” protections. FIG. 6 also shows external memory 604, the protected area 605 which stores the encryption key 606 used by crypto engine 607 to decrypt a secure object from memory 604 that is loaded in cleartext form into cache 608 for execution by the CPU. Although FIG. 6 exemplarily shows the cache 608 as receiving the decrypted object information, other configurations are possible, including configurations in which higher level caches, such as an L2 cache, are used to store the secure object while it is in the clear. In such alternative configurations, the higher level cache(s) would also be located to the left of the crypto engine 607.

Protection Options

As discussed previously, SecureBlue++ can protect the confidentiality and integrity of an application's code and data. But other options are possible. While the integrity of code and data will always be important, in some cases one may not need or want cryptographic confidentiality protection—for code or for data. A SecureBlue++ system could be designed so that

-   -   The integrity of code and data is protected in all secure         executables     -   The confidentiality of data is protected in secure executables         that require that protection     -   The confidentiality of code is protected in secure executables         that require that protection.

Depending on application requirements and “make flags”, secure executables could be built with various combinations of protection. The particular combination that would be used for a given secure executable would be communicated to the CPU via the esm operand.

Deployment Considerations for Secure Executables

The esm operand of a secure executable is encrypted using the system key of the target machine. This adds some complexity to the process of building and distributing software since different target machines will normally have different system keys. The build machine could build a unique binary for each target machine. Alternatively, the build machine could build and send a single binary to all the targets. This approach would leverage a special Deployment Server (DS) process on the target machine.

The DS would itself be a secure executable that protects sensitive information—including software that it receives from a build machine. The build machine would compile and link the software that will comprise a secure executable and securely send the software to the DS process on the target machine via standard communications security mechanisms such as SSL or TLS. The DS will generate an encryption key for the received software and encrypt the software under this key. It will then encrypt the esm operand, which includes this encryption key and the initial integrity root, under the system key of the target system.

Thus the transmitted secure executable software is protected by standard communications security mechanisms until it is safely inside the DS secure process and it will be protected inside the DS process until it has been encrypted and customized for the particular target machine.

Once the received software and its esm operand have been encrypted, the received software is a secure executable that can be safely installed in the file system.

Thus the software is always protected from the time it leaves the build machine until it is safely installed in the file system on the target machine with no point of vulnerability along the way.

Note that the DS could also use digital certificates or public keys to validate a digital signature on received software to ensure that any software received is from a legitimate trusted software publisher. Since the DS process is itself a security executable, the integrity of these digital certificates or public keys would be protected from tampering.

Similarly, secure executable mechanisms and digital certificates on the build machine would allow the build machine to validate the trustworthiness of the hardware of the target machine.

Demonstration Results

An initial prototype of a SecureBlue++-enabled CPU has been implemented on a CPU simulator and (a slightly modified) Linux (that uses the restorecontext and deletecontext instructions discussed above) and some simple demo applications have been run on this prototype in a real network. In the demonstration, it was demonstrated how a simple credit-card-authorization application can be built as either a “plain vanilla” application or as a secure executable using the same source code. It was then demonstrated that malware can obtain sensitive information from the plain vanilla application (either while it is in the file system or while it is in execution), while malware cannot obtain any sensitive information from the secure executable version.

Therefore the present invention has been demonstrated as an innovative secure processor architecture that provides for verifiably, secure applications. The architecture protects the confidentiality and integrity of information in an application so that ‘other software’ cannot access that information or undetectably tamper with it. In addition to protecting a secure application from attacks from “outside” the application, the architecture also protects against attempts to introduce malware “inside” the application via attacks such as buffer overflow or stack overflow attacks.

This architecture minimizes the amount of code that needs to be trusted. An application uses operating system services but does not need to trust the operating system or device drivers with sensitive information. The only code that an application needs to trust is its own code. The architecture allows us to know with a high level of confidence that information in an application is secure without having to prove the correctness of millions of lines of operating system, device driver, boot or other code. We just need to trust that the application itself is correct.

While the invention has been described in terms of exemplary embodiments, those skilled in the art will recognize that the invention can be practiced with modification within the spirit and scope of the appended claims.

Further, it is noted that, Applicants' intent is to encompass equivalents of all claim elements, even if amended later during prosecution. 

The invention claimed is:
 1. A computer system, comprising: a crypto mechanism that decrypts and integrity-checks Secure Object information as the Secure Object information moves into the computer system from an external storage and encrypts and updates an integrity value for Secure Object information as the Secure Object information moves out of the computer system to the external storage; and a mechanism that protects a Secure Object from code that the Secure Object receives from other software, using information contained in the Secure Object, wherein the Secure Object comprises information that is cryptographically protected so that other software on said computer system cannot access or undetectably tamper with said Secure Object information, thereby protecting both a confidentiality and an integrity of the Secure Object information from other software while making an unencrypted form of the Secure Object information available to the Secure Object itself during execution of the Secure Object.
 2. The computer system of claim 1, wherein the mechanism that protects a Secure Object from code comprises at least one register defining an address range that provides at least one of a “read-only” range and a “no-execute” range for a Secure Object.
 3. The computer system of claim 2, wherein said computer system comprises a CPU capable of executing an EnterSecureMode (esm) instruction that enables a Secure Object to access in unencrypted form its cryptographically protected information wherein said address range derives from an operand of the esm instruction.
 4. The computer system of claim 2, wherein said at least one register comprises: a first register storing a first address range in the Secure Object that is “read-only”; and a second register storing a second address range in the Secure Object that is “no-execute”.
 5. The computer system of claim 1, wherein said mechanism that protects a Secure Object from code that the Secure Object receives from other software: precludes attempts to write into a code region of the Secure Object; and precludes attempts to execute instructions from a data region of the Secure Object.
 6. The computer system of claim 1, wherein said other software comprises any of: other applications; privileged software such as an operating system; device drivers; applications running with root or superuser privileges; and malware that potentially obtains root privileges.
 7. The computer system of claim 2, further comprising a controller that implements protection features associated with said address range.
 8. The computer system of claim 3, wherein said esm instruction decrypts an operand using a private key of a public/private key pair.
 9. The computer system of claim 2 wherein said at least one register is not be accessible by software and is saved and restored during a context switch.
 10. The computer system of claim 1 wherein said mechanism that protects a Secure Object from code that the Secure Object receives from other software protects against software attack including an attack based on a buffer overflow.
 11. The computer system of claim 1 wherein said mechanism that protects a Secure Object from code that the Secure Object receives from other software derives, based on information in said Secure Object, at least one of an address range that the Secure Object cannot write into and an address range from which the Secure Object cannot execute instructions.
 12. A method, comprising: decrypting and integrity-checking Secure Object information as the Secure Object information moves into the computer system from an external storage; encrypting and updating an integrity value for the Secure Object information as the Secure Object information moves out of the computer system to the external storage; and protecting a Secure Object from code that the Secure Object receives from other software, using information contained in the Secure Object, wherein said Secure Object comprises information that is cryptographically protected so that other software on said computer system cannot access or undetectably tamper with said information, thereby protecting both a confidentiality and an integrity of the Secure Object information from other software while making an unencrypted form of the Secure Object information available to the Secure Object itself during execution of the Secure Object.
 13. The method of claim 12, wherein said computer system comprises at least one register defining an address range that provides at least one of a “read-only” range and a “no-execute” range for a Secure Object.
 14. The method of claim 13, wherein said computer system comprises a capability to execute an EnterSecureMode (esm) instruction that enables a Secure Object to access in unencrypted form its cryptographically protected information wherein said address range derives from an operand of the esm instruction.
 15. The method of claim 13, wherein said at least one register comprises: a first register storing a first address range in the Secure Object that is “read-only”; and a second register storing a second address range in the Secure Object that is “no-execute”.
 16. The method of claim 13, further comprising a method that implements protections associated with said address range.
 17. The method of claim 13, further comprising a mechanism wherein said at least one register will not be accessible by software and will be saved and restored by hardware during a context switch.
 18. The method of claim 12, as implemented as a series of machine-readable instructions tangibly embodied on a memory device on said computer system.
 19. The method of claim 18, wherein said memory device comprises instructions in a controller.
 20. A controller on a computer system providing support for a Secure Object, wherein said controller: allows a Secure Object to access its cryptographically protected information in unencrypted form; allows other software to only access the Secure Object's cryptographically protected information in encrypted form; and includes a mechanism that protects a Secure Object from code that the Secure Object receives from other software, and wherein said Secure Object comprises information that is cryptographically protected so that other software on said computer system cannot access or undetectably tamper with said information, thereby protecting both a confidentiality and an integrity of the Secure Object information from other software while making an unencrypted form of the Secure Object information available to the Secure Object itself during execution of the Secure Object.
 21. The controller of claim 20, comprising at least one register defining an address range that provides at least one of a “read-only” range and a “no-execute” range for a Secure Object.
 22. The controller of claim 21, wherein an address range stored in said at least one register derives from an operand of an EnterSecureMode (esm) instruction that enables a Secure Object to access its cryptographically protected information in unencrypted form.
 23. The controller of claim 21, wherein said at least one register comprises: a first register storing a first address range in the Secure Object that is “read-only”; and a second register storing a second address range in the Secure Object that is “no-execute”.
 24. The controller of claim 21 wherein said at least one register is not accessible by software and will be saved and restored during a context switch. 